package com.atguigu.tingshu.album.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.atguigu.tingshu.album.mapper.*;
import com.atguigu.tingshu.album.service.BaseCategoryService;
import com.atguigu.tingshu.common.cache.TsCache;
import com.atguigu.tingshu.model.album.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.injector.methods.SelectList;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.val;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Service
@SuppressWarnings({"all"})
public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, BaseCategory1> implements BaseCategoryService {

	@Autowired
	private BaseCategory1Mapper baseCategory1Mapper;

	@Autowired
	private BaseCategory2Mapper baseCategory2Mapper;

	@Autowired
	private BaseCategory3Mapper baseCategory3Mapper;


	@Autowired
	private BaseCategoryViewMapper baseCategoryViewMapper;

	@Autowired
	private BaseAttributeMapper baseAttributeMapper;

	@Override
	public List<BaseAttribute> findAttribute(Long category1Id) {
//	根据种类id查询其下属性与属性值、这里调用mapper层的方法：
		return baseAttributeMapper.selectAttribute(category1Id);
	}

    @Override
	@TsCache(keyPrefix = "categoryView:")
    public BaseCategoryView getBaseCategoryView(Long category3Id) {
        return baseCategoryViewMapper.selectById(category3Id);
    }

    @Override
    public JSONObject getAllCategoryList(Long category1Id) {
//		1.根据前端传来的一级分类id获取一级分类对象
		BaseCategory1 baseCategory1 = baseCategory1Mapper.selectById(category1Id);
//		2.声明一个JSONObject对象，用于存储一级分类信息
		JSONObject category1 = new JSONObject();
//		3.把查到的一级分类对象的id名、名称塞入我们新建的一级JSON对象中
		category1.put("categoryId",category1Id);
		category1.put("categoryName",baseCategory1.getName());
//		4.查询该一级分类下所有的分类视图信息（包含二、三级分类）
		// 使用LambdaQueryWrapper构建查询条件：查询category1Id等于参数的所有记录
		List<BaseCategoryView> baseCategoryViewList =
				baseCategoryViewMapper.selectList(new LambdaQueryWrapper<BaseCategoryView>()
						.eq(BaseCategoryView::getCategory1Id, category1Id));
//		5.对查询结果进行分组，按二级分类id进行分组，key是二级分类id，value是该二级分类下所有视图数据
		Map<Long, List<BaseCategoryView>> category2Map = baseCategoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
//		6.创建一个集合，用于存储所有二级分类的Json对象
		List<JSONObject> category2Child = new ArrayList<>();
//		遍历二级分类查询分组后的结果，弄成一个个<id,三级分类视图数据>的形式：
		for (Map.Entry<Long, List<BaseCategoryView>> entry2 : category2Map.entrySet()) {
//			获取当前二级分类ID
			Long category2Id = entry2.getKey();
//			获取当前二级分类下所有三级分类视图数据：
			List<BaseCategoryView> category3List = entry2.getValue();
//			声明一个JSONObejct对象，用于存储二级分类信息
			JSONObject category2 = new JSONObject();
			category2.put("categoryId",category2Id);
			// 从三级分类数据中获取二级分类名称（取第一个元素的category2Name）
			category2.put("categoryName",category3List.get(0).getCategory2Name());

//			7.创建一个集合，用于存储所有三级分类的JSON对象
			List<JSONObject> category3Child = new ArrayList<>();
//			遍历当前二级分类下的所有三级分类视图：
			category3List.stream().forEach(category3View->{
//				声明一个JSONObject对象，用于存储三级分类信息，每次循环
//	  都会创建一个 JSONObject category3 对象，用来存储单个三级分类的信息（ID 和名称）。
				JSONObject category3 = new JSONObject();
				category3.put("categoryId",category3View.getCategory3Id());
				category3.put("categoryName",category3View.getCategory3Name());
//				将所有三级分类JSON对象添加到集合中：
				category3Child.add(category3);
			});
//			将三级分类集合添加到二级分类JSon对象中，键为categorychild
//			给当前的二级分类对象添加它包含的所有三级分类
			category2.put("categoryChild",category3Child);
//			每次循环将该循环下创建的二级分类JSON对象添加到二级分类集合中
			category2Child.add(category2);
		}
//		将二级分类集合添加到一级分类的Json对象中
		category1.put("categoryChild",category2Child);
//		返回组装好的一级分类json对象（就一个，不需要再打包集合了）
		return category1;
    }

    @Override
    public List<BaseCategory1> findAllCategory1() {
        return baseCategory1Mapper.selectList(null);
    }

    @Override
	public List<BaseCategory3> findTopBaseCategory3ByCategory1Id(Long category1Id) {
		List<Long> category2IdList = baseCategory2Mapper.selectList(new LambdaQueryWrapper<BaseCategory2>().eq(BaseCategory2::getCategory1Id, category1Id)).stream().map(BaseCategory2::getId).collect(Collectors.toList());
		LambdaQueryWrapper<BaseCategory3> wrapper = new LambdaQueryWrapper<>();
		wrapper.in(BaseCategory3::getCategory2Id,category2IdList).eq(BaseCategory3::getIsTop,1).last(" limit 7 ");
		return baseCategory3Mapper.selectList(wrapper);
	}

	@Override
	public List<JSONObject> getBaseCategoryList(){
//		创建集合对象
		List<JSONObject> list = new ArrayList<>();
//		数据来源于数据库：种类1、种类2、种类3
//		视图：主要用于简化复杂的查询、提供数据的安全性和数据的逻辑独立性。比如，将多个表的复杂连接操作封装在视图中，用户只需要查询视图即可获取结果，而无需关心底层的表连接逻辑；
//		这里使用视图获取数据：
		List<BaseCategoryView> baseCategoryViews = baseCategoryViewMapper.selectList(null);
//		Json数据是通过map或class形式转换来的
//		使用lambda表达式进行分组去重
//		这里key = 种类id，value = List<baseCategoryView>
		Map<Long, List<BaseCategoryView>> basecatgory1Map = baseCategoryViews.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory1Id));
//		接着把List<baseCategoryView>里面的各个值给迭代出来：
		Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator = basecatgory1Map.entrySet().iterator();
		while (iterator.hasNext()){
//			获取List<baseCategoryView>里面的各个entry对象
			Map.Entry<Long, List<BaseCategoryView>> entry = iterator.next();
			Long category1Id = entry.getKey(); //list中每个值的key就是种类id
			List<BaseCategoryView> categoryViewList = entry.getValue();
			JSONObject category01 = new JSONObject();
			category01.put("categoryName",categoryViewList.get(0).getCategory1Name());
			category01.put("categoryId",category1Id);
//			获取一级分类下的二级分类数据：
			Map<Long, List<BaseCategoryView>> category2Map = categoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
			Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator1 = category2Map.entrySet().iterator();
//			存储到二级分类数据 (封装成可以给前端的json类数据category02)
			List<JSONObject> categoryChild2List = new ArrayList<>();
			while (iterator1.hasNext()){
//				获取二级分类对象数据：
				Map.Entry<Long, List<BaseCategoryView>> entry1 = iterator1.next();
				Long category2Id = entry1.getKey();
//				获取到的数据时二级分类id对应的集合数据：
				List<BaseCategoryView> categoryViewList1 = entry1.getValue();
				JSONObject category02 = new JSONObject();
				category02.put("categoryName",categoryViewList1.get(0).getCategory2Name());
				category02.put("categoryId",category2Id);
				categoryChild2List.add(category02);

//				获取三级分类数据：直接循环遍历获取三级分类数据即可
				List<JSONObject> categoryChild3List = categoryViewList1.stream().map(baseCategoryView -> {
//					创建了三级分类对象
					JSONObject category3 = new JSONObject();
					category3.put("categoryId", baseCategoryView.getCategory3Id());
					category3.put("categoryName", baseCategoryView.getCategory3Name());
//					返回数据
					return category3;
				}).collect(Collectors.toList());
				//				获取三级分类数据，添加到二级分类中
				category02.put("categoryChild",categoryChild3List);
				categoryChild2List.add(category02);

			}
//			将二级分类数据添加到一级分类里
			category01.put("categoryChild",categoryChild2List);
//			将最终的所有一级分类对象打包成list发给前端
			list.add(category01);
		}
		return list;

	}



}
